import java.nio.charset.StandardCharsets;
import java.util.*;

/**
 * 题目描述
 * 给定 m 个字符串，请计算有哪些字符在所有字符串中都出现过 n 次及以上。
 *
 * 解答要求
 * 时间限制：1000ms, 内存限制：256MB
 * 输入
 * 首行是整数 n ，取值范围 [1,100]
 * 第二行是整数 m ，表示字符串的个数，取值范围 [1,100]
 * 接下来 m 行，每行一个仅由英文字母和数字组成的字符串，长度范围 [1,1000)
 *
 * 输出
 * 按ASCII码升序输出所有符合要求的字符序列； 如果没有符合要求的字符，则输出空序列[]。
 */

public class test1 {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in, StandardCharsets.UTF_8.name());
        int nValue = cin.nextInt();
        int mValue = cin.nextInt();
        cin.nextLine();
        String[] strings = new String[mValue];
        for (int i = 0; i < mValue; i++) {
            strings[i] = cin.nextLine();
        }
        cin.close();

        char[] results = getNTimesCharacter(nValue, strings);

        System.out.print("[");
        for (int i = 0; i < results.length; i++) {
            if (i == 0) {
                System.out.print(results[i]);
            } else {
                System.out.print(" " + results[i]);
            }
        }
        System.out.print("]");
    }

    // 字符串数组按照ASCII码排序
    public static char[] charSortbyASCII(char[] arr) {
        int size = arr.length;
        char temp;
        for (int i = 0; i < size; i++) {
            for (int j = size - 1; j > i; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
        return arr;
    }

    // 待实现函数，在此函数中填入答题代码
    private static char[] getNTimesCharacter(int nValue, String[] strings) {
        // 先将第一个样本中符合要求的字符提出放入hashmap
        char[] a = strings[0].toCharArray();
        Map<String,Integer> map = new HashMap<String,Integer>();
        for (int i = 0; i < a.length; i++) {
            if (map.containsKey(String.valueOf(a[i]))) {
                map.put(String.valueOf(a[i]), map.get(String.valueOf(a[i])) + 1);
            }else {
                map.put(String.valueOf(a[i]), 1);
            }
        }
        for (Iterator<Map.Entry<String,Integer>> it = map.entrySet().iterator();it.hasNext();) {
            Map.Entry<String, Integer> next = it.next();
            int b = next.getValue();
            if (b < nValue) {
                it.remove();
            }
        }

        // 使用已符合要求的字符集map再去比对别的样本，将不符合别的样本的字符集中的字符删除
        for (int i = 1; i < strings.length; i++) {
            if (map.isEmpty()) {
                break;
            }
            char[] c = strings[i].toCharArray();
            for (Iterator<Map.Entry<String,Integer>> it = map.entrySet().iterator();it.hasNext();) {
                Map.Entry<String, Integer> entry = it.next();
                if (strings[i].indexOf(entry.getKey()) == -1) {
                    it.remove();
                    continue;
                }
                int index = 0;
                for (int j = 0; j < c.length; j++) {
                    String s = String.valueOf(c[i]);
                    String key = entry.getKey();
                    if (String.valueOf(c[j]).equals(entry.getKey())) {
                        if (index >= nValue) break;
                        index++;
                    }
                }
                if (index < nValue) {
                    it.remove();
                }
            }
        }
        char[] arr = new char[map.size()];
        int i = 0;
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            char[] chars = entry.getKey().toCharArray();
            arr[i++] = chars[0];
        }
        return charSortbyASCII(arr);
    }
}
